// AI时间线回退功能测试脚本
// 用于验证各种文件操作的回退功能

import { useAiTimelineStore } from './src/stores/aiTimeline.js';
import { invoke } from '@tauri-apps/api/core';

// 测试用的临时文件路径
const TEST_DIR = 'C:\\temp\\ai-timeline-test';
const TEST_FILE = `${TEST_DIR}\\test.txt`;
const TEST_FILE_MOVED = `${TEST_DIR}\\test-moved.txt`;
const TEST_SUBDIR = `${TEST_DIR}\\subdir`;

// 清理测试环境
async function cleanup() {
  try {
    await invoke('fs_delete', { path: TEST_DIR, recursive: true });
  } catch (e) {
    // 忽略删除失败
  }
}

// 创建测试环境
async function setup() {
  await cleanup();
  await invoke('fs_mkdir', { path: TEST_DIR, recursive: true });
}

// 测试文件创建和回退
async function testCreateAndRollback() {
  console.log('\n=== 测试文件创建和回退 ===');
  const timeline = useAiTimelineStore();
  
  // 创建文件
  await invoke('fs_write_text', { path: TEST_FILE, content: 'Hello World', createDirs: true });
  await timeline.addEntry({
    kind: 'create',
    path: TEST_FILE,
    tool: 'test',
    note: 'Test file creation',
    beforeContent: null,
    afterContent: 'Hello World'
  });
  
  // 验证文件存在
  try {
    const stat = await invoke('fs_stat', { path: TEST_FILE });
    console.log('✓ 文件创建成功:', stat.path);
  } catch (e) {
    console.error('✗ 文件创建失败:', e);
    return false;
  }
  
  // 回退创建操作
  const entries = timeline.entries;
  const createEntry = entries.find(e => e.kind === 'create' && e.path === TEST_FILE);
  if (createEntry) {
    try {
      await timeline.rollbackToEntry(createEntry.id);
      console.log('✓ 回退操作执行成功');
      
      // 验证文件已被删除
      try {
        await invoke('fs_stat', { path: TEST_FILE });
        console.error('✗ 回退失败：文件仍然存在');
        return false;
      } catch (e) {
        console.log('✓ 回退成功：文件已被删除');
        return true;
      }
    } catch (e) {
      console.error('✗ 回退操作失败:', e);
      return false;
    }
  } else {
    console.error('✗ 未找到创建操作的时间线条目');
    return false;
  }
}

// 测试文件修改和回退
async function testModifyAndRollback() {
  console.log('\n=== 测试文件修改和回退 ===');
  const timeline = useAiTimelineStore();
  
  // 创建初始文件
  const originalContent = 'Original content';
  const modifiedContent = 'Modified content';
  
  await invoke('fs_write_text', { path: TEST_FILE, content: originalContent, createDirs: true });
  
  // 修改文件
  await invoke('fs_write_text', { path: TEST_FILE, content: modifiedContent, createDirs: true });
  await timeline.addEntry({
    kind: 'modify',
    path: TEST_FILE,
    tool: 'test',
    note: 'Test file modification',
    beforeContent: originalContent,
    afterContent: modifiedContent
  });
  
  // 验证文件内容
  const currentContent = await invoke('fs_read_text', { path: TEST_FILE });
  if (currentContent !== modifiedContent) {
    console.error('✗ 文件修改失败');
    return false;
  }
  console.log('✓ 文件修改成功');
  
  // 回退修改操作
  const entries = timeline.entries;
  const modifyEntry = entries.find(e => e.kind === 'modify' && e.path === TEST_FILE);
  if (modifyEntry) {
    try {
      await timeline.rollbackToEntry(modifyEntry.id);
      console.log('✓ 回退操作执行成功');
      
      // 验证文件内容已恢复
      const restoredContent = await invoke('fs_read_text', { path: TEST_FILE });
      if (restoredContent === originalContent) {
        console.log('✓ 回退成功：文件内容已恢复');
        return true;
      } else {
        console.error('✗ 回退失败：文件内容不正确');
        return false;
      }
    } catch (e) {
      console.error('✗ 回退操作失败:', e);
      return false;
    }
  } else {
    console.error('✗ 未找到修改操作的时间线条目');
    return false;
  }
}

// 测试文件移动和回退
async function testMoveAndRollback() {
  console.log('\n=== 测试文件移动和回退 ===');
  const timeline = useAiTimelineStore();
  
  // 创建初始文件
  await invoke('fs_write_text', { path: TEST_FILE, content: 'Test content', createDirs: true });
  
  // 移动文件
  await invoke('fs_rename', { from: TEST_FILE, to: TEST_FILE_MOVED });
  await timeline.addEntry({
    kind: 'move',
    path: TEST_FILE_MOVED,
    tool: 'test',
    note: 'Test file move',
    beforeContent: null,
    afterContent: null,
    operationMeta: {
      sourcePath: TEST_FILE,
      targetPath: TEST_FILE_MOVED,
      isDirectory: false,
      beforeExists: true,
      afterExists: true
    }
  });
  
  // 验证文件已移动
  try {
    await invoke('fs_stat', { path: TEST_FILE_MOVED });
    console.log('✓ 文件移动成功');
  } catch (e) {
    console.error('✗ 文件移动失败:', e);
    return false;
  }
  
  try {
    await invoke('fs_stat', { path: TEST_FILE });
    console.error('✗ 原文件仍然存在');
    return false;
  } catch (e) {
    console.log('✓ 原文件已不存在');
  }
  
  // 回退移动操作
  const entries = timeline.entries;
  const moveEntry = entries.find(e => e.kind === 'move' && e.path === TEST_FILE_MOVED);
  if (moveEntry) {
    try {
      await timeline.rollbackToEntry(moveEntry.id);
      console.log('✓ 回退操作执行成功');
      
      // 验证文件已移回原位置
      try {
        await invoke('fs_stat', { path: TEST_FILE });
        console.log('✓ 回退成功：文件已移回原位置');
        
        try {
          await invoke('fs_stat', { path: TEST_FILE_MOVED });
          console.error('✗ 回退失败：目标文件仍然存在');
          return false;
        } catch (e) {
          console.log('✓ 目标文件已不存在');
          return true;
        }
      } catch (e) {
        console.error('✗ 回退失败：原文件不存在');
        return false;
      }
    } catch (e) {
      console.error('✗ 回退操作失败:', e);
      return false;
    }
  } else {
    console.error('✗ 未找到移动操作的时间线条目');
    return false;
  }
}

// 测试目录创建和回退
async function testDirectoryCreateAndRollback() {
  console.log('\n=== 测试目录创建和回退 ===');
  const timeline = useAiTimelineStore();
  
  // 创建目录
  await invoke('fs_mkdir', { path: TEST_SUBDIR, recursive: true });
  await timeline.addEntry({
    kind: 'create',
    path: TEST_SUBDIR,
    tool: 'test',
    note: 'Test directory creation',
    beforeContent: null,
    afterContent: null,
    operationMeta: {
      isDirectory: true,
      beforeExists: false,
      afterExists: true
    }
  });
  
  // 验证目录存在
  try {
    const stat = await invoke('fs_stat', { path: TEST_SUBDIR });
    if (stat.is_dir) {
      console.log('✓ 目录创建成功');
    } else {
      console.error('✗ 创建的不是目录');
      return false;
    }
  } catch (e) {
    console.error('✗ 目录创建失败:', e);
    return false;
  }
  
  // 回退创建操作
  const entries = timeline.entries;
  const createEntry = entries.find(e => e.kind === 'create' && e.path === TEST_SUBDIR);
  if (createEntry) {
    try {
      await timeline.rollbackToEntry(createEntry.id);
      console.log('✓ 回退操作执行成功');
      
      // 验证目录已被删除
      try {
        await invoke('fs_stat', { path: TEST_SUBDIR });
        console.error('✗ 回退失败：目录仍然存在');
        return false;
      } catch (e) {
        console.log('✓ 回退成功：目录已被删除');
        return true;
      }
    } catch (e) {
      console.error('✗ 回退操作失败:', e);
      return false;
    }
  } else {
    console.error('✗ 未找到创建操作的时间线条目');
    return false;
  }
}

// 运行所有测试
async function runAllTests() {
  console.log('开始AI时间线回退功能测试...');
  
  try {
    await setup();
    console.log('✓ 测试环境准备完成');
    
    const results = [];
    
    results.push(await testCreateAndRollback());
    await setup(); // 重置环境
    
    results.push(await testModifyAndRollback());
    await setup(); // 重置环境
    
    results.push(await testMoveAndRollback());
    await setup(); // 重置环境
    
    results.push(await testDirectoryCreateAndRollback());
    
    const passedTests = results.filter(r => r).length;
    const totalTests = results.length;
    
    console.log(`\n=== 测试结果 ===`);
    console.log(`通过: ${passedTests}/${totalTests}`);
    
    if (passedTests === totalTests) {
      console.log('🎉 所有测试通过！AI时间线回退功能工作正常。');
    } else {
      console.log('❌ 部分测试失败，需要进一步检查。');
    }
    
  } catch (e) {
    console.error('测试执行失败:', e);
  } finally {
    await cleanup();
    console.log('✓ 测试环境清理完成');
  }
}

// 导出测试函数
export { runAllTests, testCreateAndRollback, testModifyAndRollback, testMoveAndRollback, testDirectoryCreateAndRollback };

// 如果直接运行此脚本
if (typeof window !== 'undefined' && window.__TAURI_INTERNALS__) {
  // 在Tauri环境中运行
  runAllTests().catch(console.error);
} else {
  console.log('此测试脚本需要在Tauri环境中运行');
}